/*
 * MHttpConnUtils.java
 *
 * Created on April 16, 2008, 9:08 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package uns.fit.gis.httpconnection;

import java.io.*;

/**
 *
 * @author pham hiep
 */
public class MHttpConnUtils {
    private static String mark = "-_.!~*'()\"";
    static final char[] charTab =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
            .toCharArray();
    
    /** Creates a new instance of MHttpConnUtils */
    public MHttpConnUtils() {
    }
    
//    public String MUrlDecoder(String url){
//        return null;
//    }

/*--------------------------- BASE64 ENCODE & DECODE ------------------------*/    
    /** Encodes the part of the given byte array denoted by start and
     * len to the Base64 format.  The encoded data is appended to the
     * given StringBuffer. If no StringBuffer is given, a new one is
     * created automatically. The StringBuffer is the return value of
     * this method. */
    
    public static String MBase64Encode(
            byte[] data,
            int start,
            int len,
            StringBuffer buf) {
        
        if (buf == null)
            buf = new StringBuffer(data.length * 3 / 2);
        
        int end = len - 3;
        int i = start;
        int n = 0;
        
        while (i <= end) {
            int d =
                    ((((int) data[i]) & 0x0ff) << 16)
                    | ((((int) data[i + 1]) & 0x0ff) << 8)
                    | (((int) data[i + 2]) & 0x0ff);
            
            buf.append(charTab[(d >> 18) & 63]);
            buf.append(charTab[(d >> 12) & 63]);
            buf.append(charTab[(d >> 6) & 63]);
            buf.append(charTab[d & 63]);
            
            i += 3;
            
            if (n++ >= 14) {
                n = 0;
                buf.append("\r\n");
            }
        }
        
        if (i == start + len - 2) {
            int d =
                    ((((int) data[i]) & 0x0ff) << 16)
                    | ((((int) data[i + 1]) & 255) << 8);
            
            buf.append(charTab[(d >> 18) & 63]);
            buf.append(charTab[(d >> 12) & 63]);
            buf.append(charTab[(d >> 6) & 63]);
            buf.append("=");
        } else if (i == start + len - 1) {
            int d = (((int) data[i]) & 0x0ff) << 16;
            
            buf.append(charTab[(d >> 18) & 63]);
            buf.append(charTab[(d >> 12) & 63]);
            buf.append("==");
        }
        
        return buf.toString();
    }
    
    /** Decodes the given Base64 encoded String to a new byte array.
     * The byte array holding the decoded data is returned. */
    
    public byte[] MBase64Decode(String s) {
        
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            
            decode(s, bos);
            
        } catch (IOException e) {
            throw new RuntimeException();
        }
        return bos.toByteArray();
    }
    
    private void decode(String s, OutputStream os)
    throws IOException {
        int i = 0;
        
        int len = s.length();
        
        while (true) {
            while (i < len && s.charAt(i) <= ' ')
                i++;
            
            if (i == len)
                break;
            
            int tri =
                    (decode(s.charAt(i)) << 18)
                    + (decode(s.charAt(i + 1)) << 12)
                    + (decode(s.charAt(i + 2)) << 6)
                    + (decode(s.charAt(i + 3)));            
            
            os.write((tri >> 16) & 255);
            if (s.charAt(i + 2) == '=')
                break;
            os.write((tri >> 8) & 255);
            if (s.charAt(i + 3) == '=')
                break;
            os.write(tri & 255);
            
            i += 4;
        }
    }
    
    private int decode(char c) {
        
        if (c >= 'A' && c <= 'Z')
            return ((int) c) - 65;
        else if (c >= 'a' && c <= 'z')
            return ((int) c) - 97 + 26;
        else if (c >= '0' && c <= '9')
            return ((int) c) - 48 + 26 + 26;
        else
            switch (c) {
                case '+' :
                    return 62;
                case '/' :
                    return 63;
                case '=' :
                    return 0;
                default :
                    throw new RuntimeException(
                            "unexpected code: " + c);
            }
    }
    
    /**
     * Converts Hex digit to a UTF-8 "Hex" character
     * @param digitValue The decimal value
     * @return The charater represent the hexadecimal value
     */
    private static char toHexChar(int digitValue) {
        if (digitValue < 10)
            // Convert value 0-9 to char 0-9 hex char
            return (char)('0' + digitValue);
        else
            // Convert value 10-15 to A-F hex char
            return (char)('A' + (digitValue - 10));
    }

/*----------------------------- URL ENCODE & DECODE --------------------------*/
    /**
     * Encodes a URL. This method assumes UTF-8.
     * @param url The url need to be encoded.
     * @return The url have been encoded.
     */
    public static String MUrlEncoder(String url){
        StringBuffer encodedUrl = new StringBuffer(); // Encoded URL
        int len = url.length();
        // Encode each URL character
        for(int i = 0; i < len; i++) {
            char c = url.charAt(i); // Get next character
            if ((c >= '0' && c <= '9') ||
                    (c >= 'a' && c <= 'z') ||
                    (c >= 'A' && c <= 'Z'))
                // Alphanumeric characters require no encoding, append as is
                encodedUrl.append(c);
            else {
                int imark = mark.indexOf(c);
                if (imark >= 0) {
                    // Unreserved punctuation marks and symbols require
                    //  no encoding, append as is
                    encodedUrl.append(c);
                } else {
                    // Encode all other characters to Hex, using the format "%XX",
                    //  where XX are the hex digits
                    encodedUrl.append('%'); // Add % character
                    // Encode the character's high-order nibble to Hex
                    encodedUrl.append(toHexChar((c & 0xF0) >> 4));
                    // Encode the character's low-order nibble to Hex
                    encodedUrl.append(toHexChar(c & 0x0F));
                }
            }
        }
        return encodedUrl.toString(); // Return encoded URL
    }
    
    /**
     * Dncode a URL was encoded.
     * @param s The encoded url need to be decoded.
     * @return The url have been decoded.
     */
    public static String MUrlDecoder(String s){
        
        boolean needToChange = false;
        int numChars = s.length();
        StringBuffer sb = new StringBuffer(numChars > 500 ? numChars / 2 : numChars);
        int i = 0;
        
        char c;
        byte[] bytes = null;
        while (i < numChars) {
            c = s.charAt(i);
            switch (c) {
                case '+':
                    sb.append(' ');
                    i++;
                    needToChange = true;
                    break;
                case '%':
                /*
                 * Starting with this instance of %, process all
                 * consecutive substrings of the form %xy. Each
                 * substring %xy will yield a byte. Convert all
                 * consecutive  bytes obtained this way to whatever
                 * character(s) they represent in the provided
                 * encoding.
                 */                    
                    while (((i+2) < numChars) && (c=='%')) {
                        sb.append((char)Integer.parseInt(s.substring(i+1,i+3),16));
                        i+= 3;
                        if (i < numChars)
                            c = s.charAt(i);
                    }                    
                    needToChange = true;
                    break;
                default:
                    sb.append(c);
                    i++;
                    break;
            }
        }
        return (needToChange? sb.toString() : s);
    }
}
